// 使用模拟API实现替代真实API调用
// 暂时注释掉直接导入，使用动态导入代替
// import { invoke } from '@tauri-apps/api';
// import { open, save } from '@tauri-apps/api/dialog';
// import { readTextFile, writeTextFile, createDir, exists } from '@tauri-apps/api/fs';
// import { appDataDir } from '@tauri-apps/api/path';

// 模拟API实现
const mockApi = {
  invoke: async (cmd: string, args: any) => {
    console.warn(`模拟Tauri invoke调用: ${cmd}`, args);
    return null;
  },
  open: async (options: any) => {
    console.log('模拟open调用:', options);
    return "mock-file-path.txt";
  },
  save: async (options: any) => {
    console.log('模拟save调用:', options);
    return "mock-save-path.txt";
  },
  readTextFile: async (path: string) => {
    console.log('模拟readTextFile调用:', path);
    return "这是模拟的文件内容";
  },
  writeTextFile: async (path: string, content: string) => {
    console.log('模拟writeTextFile调用:', path, content?.substring(0, 50) + '...');
    return true;
  },
  createDir: async (path: string, options?: any) => {
    console.log('模拟createDir调用:', path, options);
    return true;
  },
  exists: async (path: string) => {
    console.log('模拟exists调用:', path);
    return true;
  },
  appDataDir: async () => {
    return "mock-app-data-dir";
  },
};

// 环境检测和API初始化
const isTauri = typeof window !== 'undefined' && (window as any).__TAURI__ !== undefined;
const isWebFSApiSupported = typeof window !== 'undefined' && 'showDirectoryPicker' in window;

// API实现选择
let apiImpl: any = mockApi; // 默认使用模拟API，确保初始化时有值
// 存储文件句柄的映射
let fileHandleMap = new Map<string, any>();

// 打印当前环境信息，帮助调试
console.log('文件系统环境检测:', { 
  isTauri, 
  isWebFSApiSupported, 
  userAgent: navigator.userAgent 
});

// Web环境下文件系统API的实现
const webFsApi = {
  ...mockApi, // 继承模拟API的所有功能
  // 这里只覆盖需要自定义实现的方法
  writeTextFile: async (path: string, content: string) => {
    console.log('Web FS API writeTextFile调用:', path);
    
    // 检查是否有对应的文件句柄
    const fileHandle = fileHandleMap.get(path);
    if (fileHandle) {
      try {
        // 使用文件句柄写入
        if (fileHandle._handle && typeof fileHandle._handle.createWritable === 'function') {
          const writable = await fileHandle._handle.createWritable();
          await writable.write(content);
          await writable.close();
          return true;
        }
      } catch (error) {
        console.error('Web FS API写入失败:', error);
      }
    }
    
    // 默认使用模拟实现
    console.log('未找到文件句柄，使用模拟实现保存内容:', path);
    return mockApi.writeTextFile(path, content);
  },
  
  readTextFile: async (path: string) => {
    console.log('Web FS API readTextFile调用:', path);
    
    // 检查是否有对应的文件句柄
    const fileHandle = fileHandleMap.get(path);
    if (fileHandle) {
      try {
        // 使用文件句柄读取
        if (fileHandle._handle && typeof fileHandle._handle.getFile === 'function') {
          const file = await fileHandle._handle.getFile();
          return await file.text();
        }
      } catch (error) {
        console.error('Web FS API读取失败:', error);
      }
    }
    
    // 默认使用模拟实现
    console.log('未找到文件句柄，使用模拟实现读取内容:', path);
    return mockApi.readTextFile(path);
  }
};

if (isTauri) {
  console.log('检测到Tauri环境，使用Tauri API');
  
  // 使用动态导入避免直接依赖
  const tauriImport = async () => {
    // 初始化默认API引用
    let tauriApi = { invoke: mockApi.invoke };
    let tauriDialog = { open: mockApi.open, save: mockApi.save };
    let tauriFs = { 
      readTextFile: mockApi.readTextFile, 
      writeTextFile: mockApi.writeTextFile, 
      createDir: mockApi.createDir, 
      exists: mockApi.exists 
    };
    let tauriPath = { appDataDir: mockApi.appDataDir };
    
    // 使用Function构造函数动态创建import表达式，避免webpack静态分析
    const dynamicImport = (modulePath) => {
      try {
        // 这种方法避免webpack在编译时解析import
        return new Function(`return import('${modulePath}')`)();
      } catch (e) {
        console.warn(`动态导入失败 ${modulePath}:`, e);
        return Promise.resolve(null);
      }
    };
    
    try {
      // 尝试动态导入Tauri模块
      const apiModule = await dynamicImport('@tauri-apps/api').catch(() => null);
      const dialogModule = await dynamicImport('@tauri-apps/api/dialog').catch(() => null);
      const fsModule = await dynamicImport('@tauri-apps/api/fs').catch(() => null);
      const pathModule = await dynamicImport('@tauri-apps/api/path').catch(() => null);
      
      // 更新引用（如果导入成功）
      if (apiModule) tauriApi = apiModule;
      if (dialogModule) tauriDialog = dialogModule;
      if (fsModule) tauriFs = fsModule;
      if (pathModule) tauriPath = pathModule;
      
      console.log('Tauri模块导入状态:', {
        api: !!tauriApi.invoke,
        dialog: !!tauriDialog.open,
        fs: !!tauriFs.readTextFile,
        path: !!tauriPath.appDataDir
      });
    } catch (e) {
      console.warn('动态导入失败:', e);
      // 使用初始化的模拟API
    }
    
    // 返回适当的API实现
    return { 
      invoke: tauriApi.invoke || mockApi.invoke, 
      open: tauriDialog.open || mockApi.open, 
      save: tauriDialog.save || mockApi.save, 
      readTextFile: tauriFs.readTextFile || mockApi.readTextFile, 
      writeTextFile: tauriFs.writeTextFile || mockApi.writeTextFile, 
      createDir: tauriFs.createDir || mockApi.createDir, 
      exists: tauriFs.exists || mockApi.exists, 
      appDataDir: tauriPath.appDataDir || mockApi.appDataDir 
    };
  };

  // 初始化API引用
  tauriImport().then(apis => {
    apiImpl = apis;
    console.log('Tauri APIs 加载成功');
  }).catch(err => {
    console.error('Tauri APIs 加载失败:', err);
    apiImpl = mockApi; // 降级到模拟实现
  });
} else if (isWebFSApiSupported) {
  console.log('使用 Web File System Access API');
  // 使用 Web File System Access API
  apiImpl = webFsApi;
} else {
  console.log('当前环境不支持文件系统API，使用模拟实现');
  apiImpl = mockApi; // 使用模拟实现
}

// 定义与 NovelContext 相同的类型接口，避免循环依赖
export enum ItemType {
  NOVEL = 'novel',
  VOLUME = 'volume',
  CHAPTER = 'chapter',
}

export interface TreeItem {
  id: string;
  type: ItemType;
  name: string;
  parentId?: string;
  children?: TreeItem[];
  content?: string;
  fileHandle?: any; // 添加文件句柄引用
}

// 应用数据目录
let dataDir: string;

// 初始化应用数据目录
export const initDataDir = async () => {
  try {
    const appDir = await apiImpl.appDataDir();
    console.log('应用数据目录:', appDir);
    const novelDirPath = `${appDir}/novels`;

    // 在Web环境中，创建虚拟目录结构
    if (isWebFSApiSupported) {
      // 为小说和章节目录创建虚拟文件句柄
      // 注意：这里我们不需要真正创建这些目录，只需要模拟它们的存在
      console.log('Web环境: 初始化虚拟目录结构');
      
      // 检查虚拟目录是否已存在
      if (!fileHandleMap.has(novelDirPath)) {
        fileHandleMap.set(novelDirPath, {
          name: 'novels',
          _mock: true,
          isDirectory: true
        });
      }
      
      // 创建章节目录
      const chapterDirPath = `${novelDirPath}/chapters`;
      if (!fileHandleMap.has(chapterDirPath)) {
        fileHandleMap.set(chapterDirPath, {
          name: 'chapters',
          _mock: true,
          isDirectory: true
        });
      }
      
      return novelDirPath;
    }
    
    // Tauri环境或其他环境：实际创建目录
    // 检查目录是否存在，不存在则创建
    try {
      const dirExists = await apiImpl.exists(novelDirPath);
    if (!dirExists) {
        await apiImpl.createDir(novelDirPath, { recursive: true });
      console.log('创建小说目录成功:', novelDirPath);
    }

    // 创建章节目录
    const chapterDirPath = `${novelDirPath}/chapters`;
      const chapterDirExists = await apiImpl.exists(chapterDirPath);
    if (!chapterDirExists) {
        await apiImpl.createDir(chapterDirPath, { recursive: true });
      console.log('创建章节目录成功:', chapterDirPath);
      }
    } catch (e) {
      console.error('目录创建失败，但继续使用路径:', e);
      // 即使创建失败，我们仍然返回路径，因为后续操作会回退到模拟实现
    }

    return novelDirPath;
  } catch (e) {
    console.error('初始化数据目录失败:', e);
    // 失败时返回一个默认路径，确保后续代码可以继续执行
    return "mock-app-data-dir/novels";
  }
};

// 保存小说元数据
export const saveNovelMetadata = async (novels: TreeItem[]) => {
  try {
    const novelDirPath = await initDataDir();
    if (!novelDirPath) return false;

    const metadataPath = `${novelDirPath}/novels.json`;
    const content = JSON.stringify(novels, null, 2);
    
    // 在Web环境下，创建虚拟文件句柄
    if (isWebFSApiSupported && !fileHandleMap.has(metadataPath)) {
      console.log('为元数据创建虚拟文件句柄:', metadataPath);
      fileHandleMap.set(metadataPath, {
        name: 'novels.json',
        _mock: true,
        _content: content
      });
    }
    
    try {
      // 尝试使用apiImpl保存
      await apiImpl.writeTextFile(metadataPath, content);
      console.log('元数据保存成功(使用当前API)');
      return true;
    } catch (e) {
      console.error('元数据保存失败，尝试使用模拟API:', e);
      // 如果失败，尝试直接使用模拟API
      await mockApi.writeTextFile(metadataPath, content);
      console.log('元数据保存成功(使用模拟API)');
    return true;
    }
  } catch (e) {
    console.error('保存小说元数据失败:', e);
    return false;
  }
};

// 加载小说元数据
export const loadNovelMetadata = async (): Promise<TreeItem[]> => {
  try {
    const novelDirPath = await initDataDir();
    if (!novelDirPath) return [];

    // 检查元数据文件是否存在
    const metadataPath = `${novelDirPath}/novels.json`;
    
    // 先检查是否有虚拟文件句柄
    if (fileHandleMap.has(metadataPath)) {
      const metadataHandle = fileHandleMap.get(metadataPath);
      if (metadataHandle._mock && metadataHandle._content) {
        console.log('从虚拟文件句柄加载元数据');
        try {
          return JSON.parse(metadataHandle._content);
        } catch (e) {
          console.error('解析虚拟文件句柄中的元数据失败:', e);
        }
      }
    }
    
    try {
      // 检查文件是否存在
      const fileExists = await apiImpl.exists(metadataPath);
    if (fileExists) {
        const data = await apiImpl.readTextFile(metadataPath);
        console.log('从文件系统加载元数据成功');
        return JSON.parse(data);
      }
    } catch (e) {
      console.error('从文件系统加载元数据失败，尝试使用模拟API:', e);
      // 尝试使用模拟API
      try {
        const data = await mockApi.readTextFile(metadataPath);
      return JSON.parse(data);
      } catch (e) {
        console.error('使用模拟API加载元数据失败:', e);
      }
    }

    console.log('未找到元数据，返回空数组');
    return [];
  } catch (e) {
    console.error('加载小说元数据失败:', e);
    return [];
  }
};

// 保存章节内容
export const saveChapterContent = async (chapterId: string, content: string) => {
  try {
    // 导入HTML清理函数
    const { cleanHtmlForSaving } = await import('../fileSystem/textFormatUtils.ts');
    
    // 清理HTML内容，只保留文本和段落格式
    const cleanContent = cleanHtmlForSaving(content);
    console.log('已清理HTML内容，保留文本和段落格式');
    
    // 首先检查章节是否有关联的文件句柄
    const fileHandle = fileHandleMap.get(chapterId);
    console.log('保存章节内容，章节ID:', chapterId, '有文件句柄:', !!fileHandle, fileHandle ? `(文件名: ${fileHandle.name})` : '');

    if (fileHandle) {
      // 如果有文件句柄，直接使用文件句柄写入内容
      console.log('使用文件句柄保存章节内容到原始文件:', fileHandle.name);
      try {
        // Web环境和Tauri环境处理文件句柄的方式不同
        if (fileHandle._handle && typeof fileHandle._handle.createWritable === 'function') {
          // Web环境 - 使用文件系统访问API
          console.log('使用Web文件API写入文件:', fileHandle.name);
        const writable = await fileHandle._handle.createWritable();
          await writable.write(cleanContent);
        await writable.close();
          console.log('章节内容成功保存到原始文件(通过Web文件句柄)');
          return true;
        } else if (fileHandle.path) {
          // Tauri环境，通过路径写入
          console.log('使用Tauri文件API写入文件:', fileHandle.path);
          await apiImpl.writeTextFile(fileHandle.path, cleanContent);
          console.log('章节内容成功保存到原始文件(通过Tauri路径)');
          return true;
        } else if (fileHandle._mock) {
          // 虚拟文件句柄，更新内容
          console.log('更新虚拟文件内容:', fileHandle.name);
          fileHandle._content = cleanContent;
          console.log('章节内容成功保存(通过虚拟文件)');
        return true;
        } else {
          console.warn('不支持的文件句柄类型:', JSON.stringify({
            hasHandle: !!fileHandle._handle,
            hasPath: !!fileHandle.path,
            isMock: !!fileHandle._mock,
            name: fileHandle.name
          }));
          // 失败时回退到默认方法
        }
      } catch (error) {
        console.error('通过文件句柄保存章节内容失败:', error);
        // 失败时回退到默认方法
        console.log('回退到应用数据目录保存...');
      }
    } else {
      console.log('未找到关联的文件句柄，将保存到应用数据目录');
    }

    // 默认方法：保存到应用数据目录
    const novelDirPath = await initDataDir();
    if (!novelDirPath) return false;

    // 保存文件路径和章节ID关联
    const chapterPath = `${novelDirPath}/chapters/${chapterId}.md`;
    
    // 添加日志来检查我们实际使用的是哪个API实现
    console.log('保存章节内容到应用数据路径:', chapterPath);
    console.log('使用的API类型:', isTauri ? 'Tauri' : isWebFSApiSupported ? 'Web FS API' : '模拟API');
    
    // 在Web环境下，为路径创建虚拟文件句柄，这样webFsApi可以正确处理
    if (isWebFSApiSupported && !fileHandleMap.has(chapterPath)) {
      // 创建一个虚拟文件句柄以便webFsApi能处理路径请求
      console.log('为章节创建虚拟文件句柄:', chapterPath);
      const mockFileHandle = {
        name: `${chapterId}.md`,
        _mock: true,
        _content: cleanContent
      };
      fileHandleMap.set(chapterPath, mockFileHandle);
    }
    
    try {
      // 使用API写入内容
      await apiImpl.writeTextFile(chapterPath, cleanContent);
    console.log('章节内容保存成功(通过应用数据目录)');
    return true;
    } catch (e) {
      console.error('写入文件失败，尝试使用模拟API:', e);
      // 最后的备份手段：直接使用模拟API
      await mockApi.writeTextFile(chapterPath, cleanContent);
      console.log('章节内容保存成功(通过模拟API)');
      return true;
    }
  } catch (e) {
    console.error('保存章节内容失败:', e);
    return false;
  }
};

// 加载章节内容
export const loadChapterContent = async (chapterId: string) => {
  try {
    // 首先检查章节是否有关联的文件句柄
    const fileHandle = fileHandleMap.get(chapterId);
    console.log('加载章节内容，章节ID:', chapterId, '有文件句柄:', !!fileHandle);

    if (fileHandle && !fileHandle.isDirectory) {
      // 如果有文件句柄，直接使用文件句柄读取内容
      console.log('使用文件句柄加载章节内容:', chapterId);
      try {
        // Web环境和Tauri环境处理文件句柄的方式不同
        if (fileHandle._handle && typeof fileHandle._handle.getFile === 'function') {
          // Web环境
        const file = await fileHandle._handle.getFile();
        const content = await file.text();
          console.log('章节内容加载成功(通过Web文件句柄)');
          return content;
        } else if (fileHandle.path) {
          // Tauri环境，通过路径读取
          const content = await apiImpl.readTextFile(fileHandle.path);
          console.log('章节内容加载成功(通过Tauri路径)');
        return content;
        } else if (fileHandle._mock && fileHandle._content) {
          // 处理虚拟文件句柄
          console.log('章节内容加载成功(通过虚拟文件句柄)');
          return fileHandle._content;
        } else {
          throw new Error('不支持的文件句柄类型');
        }
      } catch (error) {
        console.error('通过文件句柄加载章节内容失败:', error);
        // 失败时回退到默认方法
      }
    }

    // 默认方法：从应用数据目录加载
    const novelDirPath = await initDataDir();
    if (!novelDirPath) return null;

    const chapterPath = `${novelDirPath}/chapters/${chapterId}.md`;
    console.log('尝试从路径加载章节内容:', chapterPath);
    
    // 检查路径是否已经有文件句柄（可能是在保存时创建的虚拟文件句柄）
    if (fileHandleMap.has(chapterPath)) {
      const pathFileHandle = fileHandleMap.get(chapterPath);
      if (pathFileHandle._mock && pathFileHandle._content) {
        console.log('从虚拟文件句柄加载章节内容');
        return pathFileHandle._content;
      }
    }
    
    try {
      // 检查文件是否存在
      const fileExists = await apiImpl.exists(chapterPath);
    if (fileExists) {
        const content = await apiImpl.readTextFile(chapterPath);
      console.log('章节内容加载成功(通过应用数据目录)');
      return content;
      }
    } catch (e) {
      console.error('通过路径加载章节内容失败，尝试使用模拟API:', e);
      // 尝试使用模拟API
      return mockApi.readTextFile(chapterPath);
    }

    return null;
  } catch (e) {
    console.error('加载章节内容失败:', e);
    return null;
  }
};

// 导出小说为TXT
export const exportNovelAsTxt = async (novel: TreeItem) => {
  try {
    // 导入HTML清理函数
    const { cleanHtmlForSaving } = await import('../fileSystem/textFormatUtils.ts');
    
    // 打开保存对话框
    const filePath = await apiImpl.open({
      filters: [{ name: '文本文件', extensions: ['txt'] }],
      defaultPath: novel.name,
    });

    if (!filePath) return false;

    // 递归获取所有章节内容
    let fullContent = `${novel.name}\n\n`;

    // 递归函数收集内容
    const collectContent = async (items: TreeItem[]) => {
      for (const item of items) {
        if (item.type === ItemType.VOLUME) {
          fullContent += `\n## ${item.name}\n\n`;
        } else if (item.type === ItemType.CHAPTER) {
          fullContent += `\n### ${item.name}\n\n`;
          const content = await loadChapterContent(item.id);
          if (content) {
            // 清理HTML内容，只保留文本和段落格式
            const cleanContent = cleanHtmlForSaving(content);
            fullContent += cleanContent + '\n\n';
          }
        }

        // 如果有子项，递归处理
        if (item.children) {
          await collectContent(item.children);
        }
      }
    };

    // 处理小说的子项
    if (novel.children) {
      await collectContent(novel.children);
    }

    // 保存完整内容
    await apiImpl.writeTextFile(filePath, fullContent);
    console.log('小说导出成功:', filePath);
    return true;
  } catch (e) {
    console.error('导出小说失败:', e);
    return false;
  }
};

// 导入小说
export const importNovelFromTxt = async () => {
  try {
    // 导入文本格式处理函数
    const { preserveTextFormat } = await import('../fileSystem/textFormatUtils.ts');
    
    // 打开文件选择对话框
    const filePath = await apiImpl.open({
      filters: [{ name: '文本文件', extensions: ['txt'] }],
      multiple: false,
    });

    if (!filePath || typeof filePath !== 'string') return null;

    // 读取文件内容
    const rawContent = await apiImpl.readTextFile(filePath);
    
    // 处理文本格式，保留段落结构
    const formattedContent = preserveTextFormat(rawContent);
    console.log('TXT导入: 已处理文本格式，保留段落结构');

    // 使用文件名作为小说名
    const pathParts = filePath.split(/[/\\]/);
    const fileName = pathParts[pathParts.length - 1];
    const novelName = fileName.replace(/\.txt$/, '');

    // 创建文件句柄
    const fileId = Date.now().toString();
    const fileHandle = {
      id: fileId,
      name: fileName,
      path: filePath,
      _content: formattedContent,
      // 为Web环境添加_handle属性
      _handle: isWebFSApiSupported ? {
        getFile: async () => new File([formattedContent], fileName, { type: 'text/plain' }),
        createWritable: async () => {
          let updatedContent = formattedContent;
          return {
            write: async (newContent) => { updatedContent = newContent; },
            close: async () => {
              // 触发更新事件
              await apiImpl.writeTextFile(filePath, updatedContent);
            }
          };
        },
      } : null
    };

    // 注册文件句柄
    registerFileHandle(fileId, fileHandle);
    console.log('TXT导入: 注册文件句柄', fileId, fileName);

    // 创建小说结构
    const novel: TreeItem = {
      id: Date.now().toString(),
      name: novelName,
      type: ItemType.NOVEL,
      children: [],
    };

    // 尝试智能解析章节
    // 检查内容是否有明显的章节分隔符
    interface ChapterData {
      title: string;
      content: string;
    }

    let chapters: ChapterData[] = [];
    
    // 查找章节标题模式，例如"第X章"、"Chapter X"等
    const chapterRegex = /^(?:第[一二三四五六七八九十百千万\d]+章|Chapter\s+\d+|CHAPTER\s+\d+|[一二三四五六七八九十百千万\d]+[\s\.\-\_\:：章])/m;
    const lines = formattedContent.split('\n');
    
    let currentChapterTitle = '第一章';
    let currentChapterContent = '';
    let hasFoundChapters = false;
    
    for (let i = 0; i < lines.length; i++) {
      const line = lines[i].trim();
      
      if (line && chapterRegex.test(line)) {
        // 如果已有内容，保存前一个章节
        if (currentChapterContent.trim()) {
          chapters.push({
            title: currentChapterTitle,
            content: currentChapterContent.trim()
          });
          hasFoundChapters = true;
        }
        
        // 开始新章节
        currentChapterTitle = line;
        currentChapterContent = '';
      } else {
        // 累积内容
        currentChapterContent += line + '\n';
      }
    }
    
    // 保存最后一个章节
    if (currentChapterContent.trim()) {
      chapters.push({
        title: currentChapterTitle,
        content: currentChapterContent.trim()
      });
    }
    
    // 如果没有找到章节分隔，就将整个内容作为一个章节
    if (!hasFoundChapters || chapters.length === 0) {
      chapters = [{
        title: '第一章',
        content: formattedContent
      }];
    }
    
    // 创建卷
    const volume: TreeItem = {
      id: `${novel.id}-1`,
      name: '第一卷',
      type: ItemType.VOLUME,
      children: [],
    };

    // 如果只有一个章节，直接使用原文件
    if (chapters.length === 1) {
    const chapter: TreeItem = {
        id: fileId, // 使用文件ID作为章节ID，便于后续保存时找回文件句柄
        name: chapters[0].title,
      type: ItemType.CHAPTER,
        content: chapters[0].content,
        fileHandle: fileHandle // 关联文件句柄
    };

    volume.children = [chapter];
    } else {
      // 如果有多个章节，每个章节单独创建
      volume.children = chapters.map((chap, index) => {
        // 只有第一个章节保留原文件句柄
        const chapterId = index === 0 ? fileId : `${fileId}-chapter-${index}`;
        
        // 为其他章节创建虚拟文件句柄
        if (index > 0) {
          const chapterHandle = {
            id: chapterId,
            name: `${chap.title}.txt`,
            _mock: true,
            _content: chap.content
          };
          registerFileHandle(chapterId, chapterHandle);
          console.log(`TXT导入: 为章节创建虚拟文件句柄 ${chapterId}`);
        }
        
        return {
          id: chapterId,
          name: chap.title,
          type: ItemType.CHAPTER,
          content: chap.content,
          fileHandle: index === 0 ? fileHandle : { id: chapterId, name: `${chap.title}.txt` }
        };
      });
    }
    
    novel.children = [volume];
    console.log(`TXT导入: 创建了${chapters.length}个章节`);

    return novel;
  } catch (e) {
    console.error('导入小说失败:', e);
    return null;
  }
};

// 备份所有小说数据
export const backupAllNovels = async (novels: TreeItem[]) => {
  try {
    // 打开保存对话框
    const filePath = await apiImpl.open({
      filters: [{ name: 'JSON文件', extensions: ['json'] }],
      defaultPath: '小说备份-' + new Date().toISOString().split('T')[0],
    });

    if (!filePath) return false;

    // 保存元数据
    await apiImpl.writeTextFile(filePath, JSON.stringify(novels, null, 2));
    return true;
  } catch (e) {
    console.error('备份小说失败:', e);
    return false;
  }
};

// 导出当前环境实际的函数
// 动态将apiImpl的属性赋值给本模块导出的函数
const getApiFunction = (name: string) => {
  return (...args: any[]) => {
    if (apiImpl && typeof apiImpl[name] === 'function') {
      return apiImpl[name](...args);
    } else {
      console.warn(`API function '${name}' not available, using mock`);
      return mockApi[name](...args);
    }
  };
};

// 导出函数
const dynamicOpen = (...args: any[]) => getApiFunction('open')(...args);
const dynamicSave = (...args: any[]) => getApiFunction('save')(...args);
const dynamicReadTextFile = (...args: any[]) => getApiFunction('readTextFile')(...args);
const dynamicWriteTextFile = (...args: any[]) => getApiFunction('writeTextFile')(...args);
const dynamicCreateDir = (...args: any[]) => getApiFunction('createDir')(...args);
const dynamicExists = (...args: any[]) => getApiFunction('exists')(...args);
const dynamicAppDataDir = (...args: any[]) => getApiFunction('appDataDir')(...args);

// 注册文件句柄
export const registerFileHandle = (id: string, fileHandle: any) => {
  fileHandleMap.set(id, fileHandle);
  console.log(`已注册文件句柄: ${id}`, fileHandle.name);
};

// 获取文件句柄
export const getFileHandle = (id: string) => {
  return fileHandleMap.get(id);
};

export {
  dynamicOpen as open,
  dynamicSave as save,
  dynamicReadTextFile as readTextFile,
  dynamicWriteTextFile as writeTextFile,
  dynamicCreateDir as createDir,
  dynamicExists as exists,
  dynamicAppDataDir as appDataDir,
}; 